home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / gdb / gdb_18s.zoo / values.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-25  |  21.5 KB  |  837 lines
  1. /* Low level packing and unpacking of values for GDB.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include <stdio.h>
  22. #include "defs.h"
  23. #include "param.h"
  24. #include "symtab.h"
  25. #include "value.h"
  26.  
  27. /* The value-history records all the values printed
  28.    by print commands during this session.  Each chunk
  29.    records 60 consecutive values.  The first chunk on
  30.    the chain records the most recent values.
  31.    The total number of values is in value_history_count.  */
  32.  
  33. #define VALUE_HISTORY_CHUNK 60
  34.  
  35. struct value_history_chunk
  36. {
  37.   struct value_history_chunk *next;
  38.   value values[VALUE_HISTORY_CHUNK];
  39. };
  40.  
  41. /* Chain of chunks now in use.  */
  42.  
  43. static struct value_history_chunk *value_history_chain;
  44.  
  45. static int value_history_count;    /* Abs number of last entry stored */
  46.  
  47.  
  48. /* List of all value objects currently allocated
  49.    (except for those released by calls to release_value)
  50.    This is so they can be freed after each command.  */
  51.  
  52. static value all_values;
  53.  
  54. /* Allocate a  value  that has the correct length for type TYPE.  */
  55.  
  56. value
  57. allocate_value (type)
  58.      struct type *type;
  59. {
  60.   register value val;
  61.  
  62.   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
  63.   VALUE_NEXT (val) = all_values;
  64.   all_values = val;
  65.   VALUE_TYPE (val) = type;
  66.   VALUE_LVAL (val) = not_lval;
  67.   VALUE_ADDRESS (val) = 0;
  68.   VALUE_OFFSET (val) = 0;
  69.   VALUE_BITPOS (val) = 0;
  70.   VALUE_BITSIZE (val) = 0;
  71.   VALUE_REPEATED (val) = 0;
  72.   VALUE_REPETITIONS (val) = 0;
  73.   VALUE_REGNO (val) = -1;
  74.   return val;
  75. }
  76.  
  77. /* Allocate a  value  that has the correct length
  78.    for COUNT repetitions type TYPE.  */
  79.  
  80. value
  81. allocate_repeat_value (type, count)
  82.      struct type *type;
  83.      int count;
  84. {
  85.   register value val;
  86.  
  87.   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
  88.   VALUE_NEXT (val) = all_values;
  89.   all_values = val;
  90.   VALUE_TYPE (val) = type;
  91.   VALUE_LVAL (val) = not_lval;
  92.   VALUE_ADDRESS (val) = 0;
  93.   VALUE_OFFSET (val) = 0;
  94.   VALUE_BITPOS (val) = 0;
  95.   VALUE_BITSIZE (val) = 0;
  96.   VALUE_REPEATED (val) = 1;
  97.   VALUE_REPETITIONS (val) = count;
  98.   VALUE_REGNO (val) = -1;
  99.   return val;
  100. }
  101.  
  102. /* Free all the values that have been allocated (except for those released).
  103.    Called after each command, successful or not.  */
  104.  
  105. void
  106. free_all_values ()
  107. {
  108.   register value val, next;
  109.  
  110.   for (val = all_values; val; val = next)
  111.     {
  112.       next = VALUE_NEXT (val);
  113.       free (val);
  114.     }
  115.  
  116.   all_values = 0;
  117. }
  118.  
  119. /* Remove VAL from the chain all_values
  120.    so it will not be freed automatically.  */
  121.  
  122. void
  123. release_value (val)
  124.      register value val;
  125. {
  126.   register value v;
  127.  
  128.   if (all_values == val)
  129.     {
  130.       all_values = val->next;
  131.       return;
  132.     }
  133.  
  134.   for (v = all_values; v; v = v->next)
  135.     {
  136.       if (v->next == val)
  137.     {
  138.       v->next = val->next;
  139.       break;
  140.     }
  141.     }
  142. }
  143.  
  144. /* Return a copy of the value ARG.
  145.    It contains the same contents, for same memory address,
  146.    but it's a different block of storage.  */
  147.  
  148. static value
  149. value_copy (arg)
  150.      value arg;
  151. {
  152.   register value val;
  153.   register struct type *type = VALUE_TYPE (arg);
  154.   if (VALUE_REPEATED (arg))
  155.     val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
  156.   else
  157.     val = allocate_value (type);
  158.   VALUE_LVAL (val) = VALUE_LVAL (arg);
  159.   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
  160.   VALUE_OFFSET (val) = VALUE_OFFSET (arg);
  161.   VALUE_BITPOS (val) = VALUE_BITPOS (arg);
  162.   VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
  163.   VALUE_REGNO (val) = VALUE_REGNO (arg);
  164.   bcopy (VALUE_CONTENTS (arg), VALUE_CONTENTS (val),
  165.      TYPE_LENGTH (VALUE_TYPE (arg))
  166.      * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
  167.   return val;
  168. }
  169.  
  170. /* Access to the value history.  */
  171.  
  172. /* Record a new value in the value history.
  173.    Returns the absolute history index of the entry.  */
  174.  
  175. int
  176. record_latest_value (val)
  177.      value val;
  178. {
  179.   register int i;
  180.  
  181.   /* Get error now if about to store an invalid float.  */
  182.   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
  183.     value_as_double (val);
  184.  
  185.   /* Here we treat value_history_count as origin-zero
  186.      and applying to the value being stored now.  */
  187.  
  188.   i = value_history_count % VALUE_HISTORY_CHUNK;
  189.   if (i == 0)
  190.     {
  191.       register struct value_history_chunk *new
  192.     = (struct value_history_chunk *) xmalloc (sizeof (struct value_history_chunk));
  193.       bzero (new->values, sizeof new->values);
  194.       new->next = value_history_chain;
  195.       value_history_chain = new;
  196.     }
  197.  
  198.   value_history_chain->values[i] = val;
  199.   release_value (val);
  200.  
  201.   /* Now we regard value_history_count as origin-one
  202.      and applying to the value just stored.  */
  203.  
  204.   return ++value_history_count;
  205. }
  206.  
  207. /* Return a copy of the value in the history with sequence number NUM.  */
  208.  
  209. value
  210. access_value_history (num)
  211.      int num;
  212. {
  213.   register struct value_history_chunk *chunk;
  214.   register int i;
  215.   register int absnum = num;
  216.  
  217.   if (absnum <= 0)
  218.     absnum += value_history_count;
  219.  
  220.   if (absnum <= 0)
  221.     {
  222.       if (num == 0)
  223.     error ("The history is empty.");
  224.       else if (num == 1)
  225.     error ("There is only one value in the history.");
  226.       else
  227.     error ("History does not go back to $$%d.", -num);
  228.     }
  229.   if (absnum > value_history_count)
  230.     error ("History has not yet reached $%d.", absnum);
  231.  
  232.   absnum--;
  233.  
  234.   /* Now absnum is always absolute and origin zero.  */
  235.  
  236.   chunk = value_history_chain;
  237.   for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
  238.        i > 0; i--)
  239.     chunk = chunk->next;
  240.  
  241.   return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
  242. }
  243.  
  244. /* Clear the value history entirely.
  245.    Must be done when new symbol tables are loaded,
  246.    because the type pointers become invalid.  */
  247.  
  248. void
  249. clear_value_history ()
  250. {
  251.   register struct value_history_chunk *next;
  252.   register int i;
  253.   register value val;
  254.  
  255.   while (value_history_chain)
  256.     {
  257.       for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
  258.     if (val = value_history_chain->values[i])
  259.       free (val);
  260.       next = value_history_chain->next;
  261.       free (value_history_chain);
  262.       value_history_chain = next;
  263.     }
  264.   value_history_count = 0;
  265. }
  266.  
  267. static void
  268. history_info (num_exp)
  269.      char *num_exp;
  270. {
  271.   register int i;
  272.   register value val;
  273.   register int num;
  274.  
  275.   if (num_exp)
  276.     num = parse_and_eval_address (num_exp) - 5;
  277.   else
  278.     num = value_history_count - 9;
  279.  
  280.   if (num <= 0)
  281.     num = 1;
  282.  
  283.   for (i = num; i < num + 10 && i <= value_history_count; i++)
  284.     {
  285.       val = access_value_history (i);
  286.      printf_filtered ("$%d = ", i);
  287.       value_print (val, stdout, 0);
  288.      printf_filtered ("\n");
  289.     }
  290. }
  291.  
  292. /* Internal variables.  These are variables within the debugger
  293.    that hold values assigned by debugger commands.
  294.    The user refers to them with a '$' prefix
  295.    that does not appear in the variable names stored internally.  */
  296.  
  297. static struct internalvar *internalvars;
  298.  
  299. /* Look up an internal variable with name NAME.  NAME should not
  300.    normally include a dollar sign.
  301.  
  302.    If the specified internal variable does not exist,
  303.    one is created, with a void value.  */
  304.  
  305. struct internalvar *
  306. lookup_internalvar (name)
  307.      char *name;
  308. {
  309.   register struct internalvar *var;
  310.  
  311.   for (var = internalvars; var; var = var->next)
  312.     if (!strcmp (var->name, name))
  313.       return var;
  314.  
  315.   var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
  316.   var->name = concat (name, "", "");
  317.   var->value = allocate_value (builtin_type_void);
  318.   release_value (var->value);
  319.   var->next = internalvars;
  320.   internalvars = var;
  321.   return var;
  322. }
  323.  
  324. value
  325. value_of_internalvar (var)
  326.      struct internalvar *var;
  327. {
  328.   register value val = value_copy (var->value);
  329.   VALUE_LVAL (val) = lval_internalvar;
  330.   VALUE_INTERNALVAR (val) = var;
  331.   return val;
  332. }
  333.  
  334. void
  335. set_internalvar_component (var, offset, bitpos, bitsize, newval)
  336.      struct internalvar *var;
  337.      int offset, bitpos, bitsize;
  338.      value newval;
  339. {
  340.   register char *addr = VALUE_CONTENTS (var->value) + offset;
  341.   if (bitsize)
  342.     modify_field (addr, value_as_long (newval),
  343.           bitpos, bitsize);
  344.   else
  345.     bcopy (VALUE_CONTENTS (newval), addr,
  346.        TYPE_LENGTH (VALUE_TYPE (newval)));
  347. }
  348.  
  349. void
  350. set_internalvar (var, val)
  351.      struct internalvar *var;
  352.      value val;
  353. {
  354.   free (var->value);
  355.   var->value = value_copy (val);
  356.   release_value (var->value);
  357. }
  358.  
  359. char *
  360. internalvar_name (var)
  361.      struct internalvar *var;
  362. {
  363.   return var->name;
  364. }
  365.  
  366. /* Free all internalvars.  Done when new symtabs are loaded,
  367.    because that makes the values invalid.  */
  368.  
  369. void
  370. clear_internalvars ()
  371. {
  372.   register struct internalvar *var;
  373.  
  374.   while (internalvars)
  375.     {
  376.       var = internalvars;
  377.       internalvars = var->next;
  378.       free (var->name);
  379.       free (var->value);
  380.       free (var);
  381.     }
  382. }
  383.  
  384. static void
  385. convenience_info ()
  386. {
  387.   register struct internalvar *var;
  388.  
  389.   if (internalvars)
  390.    printf_filtered ("Debugger convenience variables:\n\n");
  391.   else
  392.    printf_filtered ("No debugger convenience variables now defined.\n\
  393. Convenience variables have names starting with \"$\";\n\
  394. use \"set\" as in \"set $foo = 5\" to define them.\n");
  395.  
  396.   for (var = internalvars; var; var = var->next)
  397.     {
  398.      printf_filtered ("$%s: ", var->name);
  399.       value_print (var->value, stdout, 0);
  400.      printf_filtered ("\n");
  401.     }
  402. }
  403.  
  404. /* Extract a value as a C number (either long or double).
  405.    Knows how to convert fixed values to double, or
  406.    floating values to long.
  407.    Does not deallocate the value.  */
  408.  
  409. long
  410. value_as_long (val)
  411.      register value val;
  412. {
  413.   /* This coerces arrays and functions, which is necessary (e.g.
  414.      in disassemble_command).  It also dereferences references, which
  415.      I suspect is the most logical thing to do.  */
  416.   if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_ENUM)
  417.     COERCE_ARRAY (val);
  418.   return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
  419. }
  420.  
  421. double
  422. value_as_double (val)
  423.      register value val;
  424. {
  425.   return unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val));
  426. }
  427. #if 0
  428. /* Extract a value as a C pointer.
  429.    Does not deallocate the value.  */
  430. CORE_ADDR
  431. value_as_pointer (val)
  432.      value val;
  433. {
  434.   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
  435.      whether we want this to be true eventually.  */
  436.   return value_as_long (val);
  437. }
  438. #endif
  439.  
  440. /* Unpack raw data (copied from debugee) at VALADDR
  441.    as a long, or as a double, assuming the raw data is described
  442.    by type TYPE.  Knows how to convert different sizes of values
  443.    and can convert between fixed and floating point.  */
  444.  
  445. long
  446. unpack_long (type, valaddr)
  447.      struct type *type;
  448.      char *valaddr;
  449. {
  450.   register enum type_code code = TYPE_CODE (type);
  451.   register int len = TYPE_LENGTH (type);
  452.   register int nosign = TYPE_UNSIGNED (type);
  453.  
  454.   if (code == TYPE_CODE_ENUM)
  455.     code = TYPE_CODE_INT;
  456.   if (code == TYPE_CODE_FLT)
  457.     {
  458.       if (len == sizeof (float))
  459.     return * (float *) valaddr;
  460.  
  461.       if (len == sizeof (double))
  462.     return * (double *) valaddr;
  463.       else
  464.       error ("Unexpected type of floating point number.");
  465.     }
  466.   else if (code == TYPE_CODE_INT && nosign)
  467.     {
  468.       if (len == sizeof (char))
  469.     return * (unsigned char *) valaddr;
  470.  
  471.       if (len == sizeof (short))
  472.     return * (unsigned short *) valaddr;
  473.  
  474.       if (len == sizeof (int))
  475.     return * (unsigned int *) valaddr;
  476.  
  477.       if (len == sizeof (long))
  478.     return * (unsigned long *) valaddr;
  479.       else
  480.       error ("That operation is not possible on an integer of that size.");
  481.     }
  482.   else if (code == TYPE_CODE_INT)
  483.     {
  484.       if (len == sizeof (char))
  485.     return * (char *) valaddr;
  486.  
  487.       if (len == sizeof (short))
  488.     return * (short *) valaddr;
  489.  
  490.       if (len == sizeof (int))
  491.     return * (int *) valaddr;
  492.  
  493.       if (len == sizeof (long))
  494.     return * (long *) valaddr;
  495.       else
  496.       error ("That operation is not possible on an integer of that size.");
  497.     }
  498.   else if (code == TYPE_CODE_PTR)
  499.     {
  500.       if (len == sizeof (char *))
  501.     return (CORE_ADDR) * (char **) valaddr;
  502.     }
  503.  
  504.   error ("Value not integer or pointer.");
  505. }
  506.  
  507. double
  508. unpack_double (type, valaddr)
  509.      struct type *type;
  510.      char *valaddr;
  511. {
  512.   register enum type_code code = TYPE_CODE (type);
  513.   register int len = TYPE_LENGTH (type);
  514.   register int nosign = TYPE_UNSIGNED (type);
  515.  
  516.   if (code == TYPE_CODE_FLT)
  517.     {
  518.       if (INVALID_FLOAT (valaddr, len))
  519.     error ("Invalid floating value found in program.");
  520.  
  521.       if (len == sizeof (float))
  522.     return * (float *) valaddr;
  523.  
  524.       if (len == sizeof (double))
  525.     {
  526.       /* Some machines require doubleword alignment for doubles.
  527.          This code works on them, and on other machines.  */
  528.       double temp;
  529.       bcopy ((char *) valaddr, (char *) &temp, sizeof (double));
  530.       return temp;
  531.     }
  532.       else
  533.       error ("Unexpected type of floating point number.");
  534.     }
  535.   else if (nosign)
  536.   {
  537.       /* Unsigned -- be sure we compensate for signed LONGEST.  */
  538.       return (unsigned long     ) unpack_long (type, valaddr);
  539.   }
  540.   else
  541.   {
  542.       /* Signed -- we are OK with unpack_long.  */
  543.       return unpack_long (type, valaddr);
  544.   }
  545. }
  546.  
  547. #if 0
  548. CORE_ADDR
  549. unpack_pointer (type, valaddr)
  550.      struct type *type;
  551.      char *valaddr;
  552. {
  553.   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
  554.      whether we want this to be true eventually.  */
  555.   return unpack_long (type, valaddr);
  556. }
  557. #endif
  558.  
  559. /* Given a value ARG1 of a struct or union type,
  560.    extract and return the value of one of its fields.
  561.    FIELDNO says which field.  */
  562.  
  563. value
  564. value_field (arg1, fieldno)
  565.      register value arg1;
  566.      register int fieldno;
  567. {
  568.   register value v;
  569.   register struct type *type = TYPE_FIELD_TYPE (VALUE_TYPE (arg1), fieldno);
  570.   register int offset;
  571.  
  572.   /* Handle packed fields */
  573.  
  574.   offset = TYPE_FIELD_BITPOS (VALUE_TYPE (arg1), fieldno) / 8;
  575.   if (TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno))
  576.     {
  577.       v = value_from_long (type,
  578.                unpack_field_as_long (VALUE_TYPE (arg1),
  579.                          VALUE_CONTENTS (arg1),
  580.                          fieldno));
  581.       VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (VALUE_TYPE (arg1), fieldno) % 8;
  582.       VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno);
  583.     }
  584.   else
  585.     {
  586.       v = allocate_value (type);
  587.       bcopy (VALUE_CONTENTS (arg1) + offset,
  588.          VALUE_CONTENTS (v),
  589.          TYPE_LENGTH (type));
  590.     }
  591.   VALUE_LVAL (v) = VALUE_LVAL (arg1);
  592.   if (VALUE_LVAL (arg1) == lval_internalvar)
  593.     VALUE_LVAL (v) = lval_internalvar_component;
  594.   VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
  595.   VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
  596.   return v;
  597. }
  598.  
  599. long
  600. unpack_field_as_long (type, valaddr, fieldno)
  601.      struct type *type;
  602.      char *valaddr;
  603.      int fieldno;
  604. {
  605.   long val;
  606.   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
  607.   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
  608.  
  609.   bcopy (valaddr + bitpos / 8, &val, sizeof val);
  610.  
  611.   /* Extracting bits depends on endianness of the machine.  */
  612. #if 0
  613.     /* Little-endian.  */
  614.     val = val >> (bitpos % 8);
  615.   else
  616. #endif
  617.     val = val >> (sizeof val * 8 - bitpos % 8 - bitsize);
  618.  
  619.   if (bitsize < 8 * sizeof (val))
  620.     val &= (((unsigned long)1) << bitsize) - 1;
  621.   return val;
  622. }
  623.  
  624. modify_field (addr, fieldval, bitpos, bitsize)
  625.      char *addr;
  626.      int fieldval;
  627.      int bitpos, bitsize;
  628. {
  629.   long oword;
  630.   union { int i; char c; } test;
  631.  
  632.   /* Reject values too big to fit in the field in question,
  633.      otherwise adjoining fields may be corrupted.  */
  634.   if (bitsize < (8 * sizeof (fieldval))
  635.       && 0 != (fieldval & ~((1<<bitsize)-1)))
  636.     error ("Value %d does not fit in %d bits.", fieldval, bitsize);
  637.  
  638.   bcopy (addr, &oword, sizeof oword);
  639.  
  640.   /* Shifting for bit field depends on endianness of the machine.  */
  641. #if 0
  642.   test.c = 1;
  643.   if (test.i != 1)
  644. #endif
  645.     /* not little-endian: assume big-endian.  */
  646.     bitpos = sizeof oword * 8 - bitpos - bitsize;
  647.  
  648.   /* Mask out old value, while avoiding shifts >= longword size */
  649.   if (bitsize < 8 * sizeof (oword))
  650.     oword &= ~(((((unsigned long)1) << bitsize) - 1) << bitpos);
  651.   else
  652.     oword &= ~((-1) << bitpos);
  653.   oword |= fieldval << bitpos;
  654.   bcopy (&oword, addr, sizeof oword);
  655. }
  656.  
  657. /* Convert C numbers into newly allocated values */
  658.  
  659. value
  660. value_from_long (type, num)
  661.      struct type *type;
  662.      register long num;
  663. {
  664.   register value val = allocate_value (type);
  665.   register enum type_code code = TYPE_CODE (type);
  666.   register int len = TYPE_LENGTH (type);
  667.  
  668.   if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM)
  669.     {
  670.       if (len == sizeof (char))
  671.     * (char *) VALUE_CONTENTS (val) = num;
  672.       else if (len == sizeof (short))
  673.     * (short *) VALUE_CONTENTS (val) = num;
  674.       else if (len == sizeof (int))
  675.     * (int *) VALUE_CONTENTS (val) = num;
  676.       else if (len == sizeof (long))
  677.     * (long *) VALUE_CONTENTS (val) = num;
  678.       else
  679.     error ("Integer type encountered with unexpected data length.");
  680.     }
  681.   else
  682.     error ("Unexpected type encountered for integer constant.");
  683.  
  684.   return val;
  685. }
  686.  
  687. value
  688. value_from_double (type, num)
  689.      struct type *type;
  690.      double num;
  691. {
  692.   register value val = allocate_value (type);
  693.   register enum type_code code = TYPE_CODE (type);
  694.   register int len = TYPE_LENGTH (type);
  695.  
  696.   if (code == TYPE_CODE_FLT)
  697.     {
  698.       if (len == sizeof (float))
  699.     * (float *) VALUE_CONTENTS (val) = num;
  700.       else if (len == sizeof (double))
  701.     * (double *) VALUE_CONTENTS (val) = num;
  702.       else
  703.     error ("Floating type encountered with unexpected data length.");
  704.     }
  705.   else
  706.     error ("Unexpected type encountered for floating constant.");
  707.  
  708.   return val;
  709. }
  710.  
  711. /* Deal with the value that is "about to be returned".  */
  712.  
  713. /* Return the value that a function returning now
  714.    would be returning to its caller, assuming its type is VALTYPE.
  715.    RETBUF is where we look for what ought to be the contents
  716.    of the registers (in raw form).  This is because it is often
  717.    desirable to restore old values to those registers
  718.    after saving the contents of interest, and then call
  719.    this function using the saved values.  */
  720.  
  721. value
  722. value_being_returned (valtype, retbuf, struct_return)
  723.      register struct type *valtype;
  724.      char retbuf[REGISTER_BYTES];
  725.      int struct_return;
  726.      /*ARGSUSED*/
  727. {
  728.   register value val;
  729.   CORE_ADDR addr;
  730.  
  731. #if 1 /* defined (EXTRACT_STRUCT_VALUE_ADDRESS) */
  732.   /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
  733.   if (struct_return) {
  734.     addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
  735.     if (!addr)
  736.       error ("Function return value unknown");
  737.     return value_at (valtype, addr);
  738.   }
  739. #endif
  740.  
  741.   val = allocate_value (valtype);
  742.   EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
  743.  
  744.   return val;
  745. }
  746.  
  747. /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
  748.    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
  749.    and TYPE is the type (which is known to be struct, union or array).
  750.  
  751.    On most machines, the struct convention is used unless we are
  752.    using gcc and the type is of a special size.  */
  753. #if !defined (USE_STRUCT_CONVENTION)
  754. #define USE_STRUCT_CONVENTION(gcc_p, type)\
  755.   (!((gcc_p) && (TYPE_LENGTH (value_type) == 1                \
  756.          || TYPE_LENGTH (value_type) == 2             \
  757.              || TYPE_LENGTH (value_type) == 4             \
  758.          || TYPE_LENGTH (value_type) == 8             \
  759.          )                                            \
  760.      ))
  761. #endif
  762.  
  763. /* Return true if the function specified is using the structure returning
  764.    convention on this machine to return arguments, or 0 if it is using
  765.    the value returning convention.  FUNCTION is the value representing
  766.    the function, FUNCADDR is the address of the function, and VALUE_TYPE
  767.    is the type returned by the function.  GCC_P is nonzero if compiled
  768.    with GCC.  */
  769.  
  770. int
  771. using_struct_return (function, funcaddr, value_type, gcc_p)
  772.      value function;
  773.      CORE_ADDR funcaddr;
  774.      struct type *value_type;
  775.      int gcc_p;
  776.      /*ARGSUSED*/
  777. {
  778.   register enum type_code code = TYPE_CODE (value_type);
  779.  
  780. #if 0
  781.   if (code == TYPE_CODE_ERROR)
  782.     error ("Function return type unknown.");
  783. #endif
  784.  
  785.   if (code == TYPE_CODE_STRUCT ||
  786.       code == TYPE_CODE_UNION ||
  787.       code == TYPE_CODE_ARRAY)
  788.     return USE_STRUCT_CONVENTION (gcc_p, value_type);
  789.  
  790.   return 0;
  791. }
  792.  
  793. /* Store VAL so it will be returned if a function returns now.
  794.    Does not verify that VAL's type matches what the current
  795.    function wants to return.  */
  796.  
  797. void
  798. set_return_value (val)
  799.      value val;
  800. {
  801.   register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
  802.   char regbuf[REGISTER_BYTES];
  803.   double dbuf;
  804.   long lbuf;
  805.  
  806.   if (code == TYPE_CODE_STRUCT
  807.       || code == TYPE_CODE_UNION)
  808.     error ("Specifying a struct or union return value is not supported.");
  809.  
  810.   if (code == TYPE_CODE_FLT)
  811.     {
  812.       dbuf = value_as_double (val);
  813.  
  814.       STORE_RETURN_VALUE (VALUE_TYPE (val), &dbuf);
  815.     }
  816.   else
  817.     {
  818.       lbuf = value_as_long (val);
  819.       STORE_RETURN_VALUE (VALUE_TYPE (val), &lbuf);
  820.     }
  821. }
  822.  
  823. void 
  824. initialize_values ()
  825. {
  826.   add_info ("convenience", convenience_info,
  827.         "Debugger convenience (\"$foo\") variables.\n\
  828. These variables are created when you assign them values;\n\
  829. thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
  830. A few convenience variables are given values automatically GDB:\n\
  831. \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
  832. \"$__\" holds the contents of the last address examined with \"x\".");
  833.  
  834.   add_info ("history", history_info,
  835.         "Elements of value history (around item number IDX, or last ten).");
  836. }
  837.